package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade HIDROMETRO
 * @author Gerado pelo Telescope
 */
public class EntHidrometro extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.HIDROMETRO";
    public final static String TABLE_NAME = "HIDROMETRO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntHidrometro() {
        super();
        initialize();
    }
    
    public EntHidrometro(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNumeroSerie = new DomText(this,"NUMERO_SERIE", "Número de série do hidrômetro"); 
        aNumeroSerie.setRequired(true);
        aNumeroSerie.setSize(32);
        oNumeroSerie = new DomText();
        aDataRegistro = new DomDateTime(this,"DATA_REGISTRO", "Data do registro"); 
        aDataRegistro.setRequired(true);
        aDataRegistro.setDefaultValue("[SYSDATE]");
        oDataRegistro = new DomDateTime();
        aEnsaioBancadaId = new DomId(this,"ENSAIO_BANCADA_ID", "Ensaio (origem)"); 
        aEnsaioBancadaId.setRequired(true);
        oEnsaioBancadaId = new DomId();
        aModeloHidrometroId = new DomId(this,"MODELO_HIDROMETRO_ID", "Modelo do hidrômetro"); 
        aModeloHidrometroId.setRequired(true);
        oModeloHidrometroId = new DomId();
        aNumeroLacre = new DomInteger(this,"NUMERO_LACRE", "Número do lacre"); 
        oNumeroLacre = new DomInteger();
        aCargaNumerica = new DomText(this,"CARGA_NUMERICA", "Carga numérica"); 
        oCargaNumerica = new DomText();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Número de série do hidrômetro
    private DomText aNumeroSerie;
    private DomText oNumeroSerie;
    
    // Data do registro
    private DomDateTime aDataRegistro;
    private DomDateTime oDataRegistro;
    
    // Ensaio (origem)
    private DomId aEnsaioBancadaId;
    private DomId oEnsaioBancadaId;
    
    // Modelo do hidrômetro
    private DomId aModeloHidrometroId;
    private DomId oModeloHidrometroId;
    
    // Número do lacre
    private DomInteger aNumeroLacre;
    private DomInteger oNumeroLacre;
    
    // Carga numérica
    private DomText aCargaNumerica;
    private DomText oCargaNumerica;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntHidrometro id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NUMERO_SERIE">
    
    public EntHidrometro numeroSerie(String value) {
        setNumeroSerie(value);
        return this;
    }
    
    public void setNumeroSerie(DomText value) {
        if (value == null || value.isNull()) {
            nullifyNumeroSerie();
        } else {
            aNumeroSerie.setValue(value.getValue());
            if (aNumeroSerie.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroSerie(String value) {
        if (value == null) {
            nullifyNumeroSerie();
        } else {
            aNumeroSerie.setValue(value);
            if (aNumeroSerie.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroSerie(Object value) {
        aNumeroSerie.setValue(value);
        if (aNumeroSerie.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNumeroSerie() {
        if (!aNumeroSerie.isNull()) {
            aNumeroSerie.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getNumeroSerie() {
        return aNumeroSerie;
    }
    
    public DomText oldNumeroSerie() {
        return oNumeroSerie;
    }
    
    public String valueOfNumeroSerie() {
        return aNumeroSerie.getValue();
    }
    
    public boolean isNumeroSerieModified() {
        return aNumeroSerie.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_REGISTRO">
    
    public EntHidrometro dataRegistro(java.sql.Timestamp value) {
        setDataRegistro(value);
        return this;
    }
    
    public void setDataRegistro(DomDateTime value) {
        if (value == null || value.isNull()) {
            nullifyDataRegistro();
        } else {
            aDataRegistro.setValue(value.getValue());
            if (aDataRegistro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataRegistro(String value) {
        if (value == null) {
            nullifyDataRegistro();
        } else {
            aDataRegistro.setValue(value);
            if (aDataRegistro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataRegistro(java.sql.Timestamp value) {
        aDataRegistro.setValue(value);
        if (aDataRegistro.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataRegistro(Object value) {
        aDataRegistro.setValue(value);
        if (aDataRegistro.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataRegistro() {
        if (!aDataRegistro.isNull()) {
            aDataRegistro.setNull(true);
            setModified(true);
        }
    }
    
    public DomDateTime getDataRegistro() {
        return aDataRegistro;
    }
    
    public DomDateTime oldDataRegistro() {
        return oDataRegistro;
    }
    
    public java.sql.Timestamp valueOfDataRegistro() {
        return aDataRegistro.getValue();
    }
    
    public boolean isDataRegistroModified() {
        return aDataRegistro.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ENSAIO_BANCADA_ID">
    
    public EntHidrometro ensaioBancadaId(Long value) {
        setEnsaioBancadaId(value);
        return this;
    }
    
    public void setEnsaioBancadaId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyEnsaioBancadaId();
        } else {
            aEnsaioBancadaId.setValue(value.getValue());
            if (aEnsaioBancadaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEnsaioBancadaId(String value) {
        if (value == null) {
            nullifyEnsaioBancadaId();
        } else {
            aEnsaioBancadaId.setValue(value);
            if (aEnsaioBancadaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEnsaioBancadaId(Long value) {
        aEnsaioBancadaId.setValue(value);
        if (aEnsaioBancadaId.isModified()) {
            setModified(true);
        }
    }
    
    public void setEnsaioBancadaId(Object value) {
        aEnsaioBancadaId.setValue(value);
        if (aEnsaioBancadaId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyEnsaioBancadaId() {
        if (!aEnsaioBancadaId.isNull()) {
            aEnsaioBancadaId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getEnsaioBancadaId() {
        return aEnsaioBancadaId;
    }
    
    public DomId oldEnsaioBancadaId() {
        return oEnsaioBancadaId;
    }
    
    public Long valueOfEnsaioBancadaId() {
        return aEnsaioBancadaId.getValue();
    }
    
    public boolean isEnsaioBancadaIdModified() {
        return aEnsaioBancadaId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MODELO_HIDROMETRO_ID">
    
    public EntHidrometro modeloHidrometroId(Long value) {
        setModeloHidrometroId(value);
        return this;
    }
    
    public void setModeloHidrometroId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyModeloHidrometroId();
        } else {
            aModeloHidrometroId.setValue(value.getValue());
            if (aModeloHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setModeloHidrometroId(String value) {
        if (value == null) {
            nullifyModeloHidrometroId();
        } else {
            aModeloHidrometroId.setValue(value);
            if (aModeloHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setModeloHidrometroId(Long value) {
        aModeloHidrometroId.setValue(value);
        if (aModeloHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void setModeloHidrometroId(Object value) {
        aModeloHidrometroId.setValue(value);
        if (aModeloHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyModeloHidrometroId() {
        if (!aModeloHidrometroId.isNull()) {
            aModeloHidrometroId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getModeloHidrometroId() {
        return aModeloHidrometroId;
    }
    
    public DomId oldModeloHidrometroId() {
        return oModeloHidrometroId;
    }
    
    public Long valueOfModeloHidrometroId() {
        return aModeloHidrometroId.getValue();
    }
    
    public boolean isModeloHidrometroIdModified() {
        return aModeloHidrometroId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NUMERO_LACRE">
    
    public EntHidrometro numeroLacre(Integer value) {
        setNumeroLacre(value);
        return this;
    }
    
    public void setNumeroLacre(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyNumeroLacre();
        } else {
            aNumeroLacre.setValue(value.getValue());
            if (aNumeroLacre.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroLacre(String value) {
        if (value == null) {
            nullifyNumeroLacre();
        } else {
            aNumeroLacre.setValue(value);
            if (aNumeroLacre.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroLacre(Integer value) {
        aNumeroLacre.setValue(value);
        if (aNumeroLacre.isModified()) {
            setModified(true);
        }
    }
    
    public void setNumeroLacre(Object value) {
        aNumeroLacre.setValue(value);
        if (aNumeroLacre.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNumeroLacre() {
        if (!aNumeroLacre.isNull()) {
            aNumeroLacre.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getNumeroLacre() {
        return aNumeroLacre;
    }
    
    public DomInteger oldNumeroLacre() {
        return oNumeroLacre;
    }
    
    public Integer valueOfNumeroLacre() {
        return aNumeroLacre.getValue();
    }
    
    public boolean isNumeroLacreModified() {
        return aNumeroLacre.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CARGA_NUMERICA">
    
    public EntHidrometro cargaNumerica(String value) {
        setCargaNumerica(value);
        return this;
    }
    
    public void setCargaNumerica(DomText value) {
        if (value == null || value.isNull()) {
            nullifyCargaNumerica();
        } else {
            aCargaNumerica.setValue(value.getValue());
            if (aCargaNumerica.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCargaNumerica(String value) {
        if (value == null) {
            nullifyCargaNumerica();
        } else {
            aCargaNumerica.setValue(value);
            if (aCargaNumerica.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCargaNumerica(Object value) {
        aCargaNumerica.setValue(value);
        if (aCargaNumerica.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCargaNumerica() {
        if (!aCargaNumerica.isNull()) {
            aCargaNumerica.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getCargaNumerica() {
        return aCargaNumerica;
    }
    
    public DomText oldCargaNumerica() {
        return oCargaNumerica;
    }
    
    public String valueOfCargaNumerica() {
        return aCargaNumerica.getValue();
    }
    
    public boolean isCargaNumericaModified() {
        return aCargaNumerica.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_HIDROMETRO
        {
            EntHidrometroEnsaio external = new EntHidrometroEnsaio(ctx);
            external.findByHidrometro(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_HIDROMETRO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Hidrômetros relacionados para os ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_HROEN_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_HIDROMETRO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Hidrômetros relacionados para os ensaios fazendo referencia para este registro! (FK_HROEN_HIDROMETRO)");
                return e;
            } else {
                e = new AdsException("ZTEST.HIDROMETRO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("FK_HIDRMT_MODELO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO.FK_HIDRMT_MODELO_HIDROMETRO", 
                        Severity.ERROR,
                        "Registro não cadastrado para MODELO_HIDROMETRO! (FK_HIDRMT_MODELO_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("UK_HIDRMT_CODIGO") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO.UK_HIDRMT_CODIGO", 
                        Severity.ERROR,
                        "Registro duplicado! O código do hidrômetro deve ser único Número de série do hidrômetro ${NUMERO_SERIE} (UK_HIDRMT_CODIGO)");
                return e;
            } else if (msg.indexOf("PK_HIDRMT") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO.PK_HIDRMT", 
                        Severity.ERROR,
                        "ID duplicado! (PK_HIDRMT)");
                return e;
            } else {
                e = new AdsException("ZTEST.HIDROMETRO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNumeroSerie);
            allAttributes.add(aDataRegistro);
            allAttributes.add(aEnsaioBancadaId);
            allAttributes.add(aModeloHidrometroId);
            allAttributes.add(aNumeroLacre);
            allAttributes.add(aCargaNumerica);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNumeroSerie().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNumeroSerie(String numeroSerie) throws AdsException {
        findBy(new String[] {"NUMERO_SERIE"},
                new Object[] {numeroSerie});
    }
    
    private EntModeloHidrometro eModeloHidrometro;
    
    public EntModeloHidrometro findModeloHidrometro() throws AdsException {
        if (getModeloHidrometroId().isNull()) {
            return null;
        }
        if (eModeloHidrometro == null || !valueOfModeloHidrometroId().equals(eModeloHidrometro.valueOfId())) {
            eModeloHidrometro = new EntModeloHidrometro(ctx);
            eModeloHidrometro.find(valueOfModeloHidrometroId());
        }
        return eModeloHidrometro;
    }
    
    /**
     * Ativa o join desta entidade com MODELO_HIDROMETRO
     * através do atributo MODELO_HIDROMETRO_ID
     */
    public EntModeloHidrometro joinModeloHidrometro() {
        return joinModeloHidrometro(null);
    }
    public EntModeloHidrometro joinModeloHidrometro(String alias) {
        EntModeloHidrometro entity = new EntModeloHidrometro(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getModeloHidrometroId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByModeloHidrometro(long id, String sqlAppend) throws AdsException {
        find("select ID from HIDROMETRO where MODELO_HIDROMETRO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByModeloHidrometro(long id) throws AdsException {
        findByModeloHidrometro(id,"");
    }
    
    public void findByModeloHidrometro(Entity entidade) throws AdsException {
        findByModeloHidrometro(entidade.valueOfId(),"");
    }
    
    public void findByModeloHidrometro(Entity entidade, String sqlAppend) throws AdsException {
        findByModeloHidrometro(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eModeloHidrometro = null;
    }
    /**
     * Retorna os registros de HIDROMETRO_ENSAIO que referenciam este registro através do atributo HIDROMETRO_ID
     */
    public EntHidrometroEnsaio findAllHidrometroEnsaioHidrometro() throws AdsException {
        return findAllHidrometroEnsaioHidrometro("order by ID");
    }
    
    /**
     * Retorna os registros de HIDROMETRO_ENSAIO que referenciam este registro através do atributo HIDROMETRO_ID
     */
    public EntHidrometroEnsaio findAllHidrometroEnsaioHidrometro(String sqlAppend) throws AdsException {
        EntHidrometroEnsaio out = new EntHidrometroEnsaio(ctx);
        out.find("select ID from HIDROMETRO_ENSAIO where HIDROMETRO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oNumeroSerie.setValue(aNumeroSerie);
        oCargaNumerica.setValue(aCargaNumerica);
        oNumeroLacre.setValue(aNumeroLacre);
        oModeloHidrometroId.setValue(aModeloHidrometroId);
        oEnsaioBancadaId.setValue(aEnsaioBancadaId);
        oDataRegistro.setValue(aDataRegistro);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntHidrometro.class);
            rule.setName("PK_HIDRMT");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntHidrometro.class);
            rule.setAssociatedEntity(EntModeloHidrometro.class);
            rule.setName("FK_HIDRMT_MODELO_HIDROMETRO");
            rule.addAttribute(new DomId("MODELO_HIDROMETRO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntHidrometro.class);
            rule.setName("UK_HIDRMT_CODIGO");
            rule.addAttribute(new DomText("NUMERO_SERIE",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        calcularCodigoHidrometro(); //Calcular o código do hidrômetro
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getDataRegistro().isNull()) {
            setDataRegistro(getDataRegistro().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Regra de ação: Calcular o código do hidrômetro
     */
    private void calcularCodigoHidrometro() throws AdsException {
        // <user-code id="20903168" parentId="20902865" hashcode="-6099f177" length="491">
        EntVazaoPrefixoSerie vazaoSerie = new EntVazaoPrefixoSerie(ctx);
        vazaoSerie.findByVazaoNominal(findModeloHidrometro().findVazaoPrefixoSerie().valueOfVazaoNominal());
        if (vazaoSerie.next()) {
            setNumeroSerie(vazaoSerie.calcularIdentificacaoHidrometro());
        } else {
            ctx.pushError(ENTITY_NAME,
                    Severity.ERROR,
                    "Vazão informada no modelo de hidrômentro não cadastrada! Revise o cadastro de vazão e série e o cadastro deste modelo.");
        } 
        vazaoSerie.close();
        // </user-code>
    }
}
